use common::protocol::XID;
use tokio::sync::RwLock;

use std::{collections::HashMap, sync::Arc};

pub enum MessageStatus {
    // 这个的状态必须要有大小之分, 具体看UpdateMsgState, 消息只能单向的更新
    NoMsg, // 没有状态
    // 这是一组状态
    WaitForSnd, //等待发送
    HasSnd,     // 已经发送了
    Ack,        // 已经确认消息了	被对方确认了
    Recv,       // 接受,别人发过来的消息直接就是recv了, 没有内存引用
    // 这是一组状态
    WaitHandle,     //等待处理中
    HandleIng,      // 处理中, 消息正在处理了
    Handled,        // 消息处理完毕了
    TimeOutDiscard, // 因为超时, 因此不做处理
}

pub struct MonitorMessageInfo {
    // xid
    pub msg_xid: XID,
    // 发送的次数
    pub send_times: u16,
}

struct MessageHolder {
    // 消息从那条通道接收的
    pub channel_id: i64,
    // 消息ID, CurReqId
    pub msg_id: i64,
    // 消息的长度
    pub data: Arc<Vec<u8>>,
}

struct MessageHolderWrapper {
    pub conn_id: i64,

    message_map: HashMap<i64, MessageHolder>,
}

pub struct MessageManager {
    message_wrapper_map: RwLock<HashMap<i64, MessageHolderWrapper>>,
}

impl MessageManager {
    pub fn new() -> MessageManager {
        MessageManager {
            message_wrapper_map: RwLock::new(HashMap::new()),
        }
    }
    /**
     *
     */
    pub async fn add_message(&self, channel_id: i64, xid: XID, data: Arc<Vec<u8>>) -> bool {
        let mut map = self.message_wrapper_map.write().await;

        let msg_wrapper_map = map.entry(xid.conn_id).or_insert(MessageHolderWrapper {
            conn_id: xid.conn_id,
            message_map: HashMap::new(),
        });

        let msg_holder = msg_wrapper_map.message_map.get_mut(&xid.request_id);
        if msg_holder.is_some() {
            return false;
        }
        msg_wrapper_map.message_map.insert(
            xid.request_id,
            MessageHolder {
                channel_id: channel_id,
                data: data,
                msg_id: xid.request_id,
            },
        );
        true
    }

    pub async fn delete_message(&self, xid: XID) {
        let mut map = self.message_wrapper_map.write().await;
        let msg_wrapper = map.get_mut(&xid.conn_id);

        if msg_wrapper.is_none() {
            return;
        }

        let msg_wrapper = msg_wrapper.unwrap();

        msg_wrapper.message_map.remove(&xid.request_id);

        if msg_wrapper.message_map.len() == 0 {
            map.remove(&xid.conn_id);
        }
    }

    pub async fn get_msg_from_channel_id(&self, xid: &XID) -> Option<i64> {
        let map = self.message_wrapper_map.read().await;

        let msg_wrapper = map.get(&xid.conn_id);

        if msg_wrapper.is_none() {
            return None;
        }

        let msg_wrapper = msg_wrapper.unwrap();

        let msg_holder = msg_wrapper.message_map.get(&xid.request_id);

        if msg_holder.is_none() {
            return None;
        }
        let msg_holder = msg_holder.unwrap();
        //
        Some(msg_holder.channel_id)
    }
    /**
     * 返回消息，和 channel_id
     */
    pub async fn get_msg(&self, xid: &XID) -> Option<(Arc<Vec<u8>>, i64)> {
        let map = self.message_wrapper_map.read().await;

        let msg_wrapper = map.get(&xid.conn_id);

        if msg_wrapper.is_none() {
            return None;
        }

        let msg_wrapper = msg_wrapper.unwrap();

        let msg_holder = msg_wrapper.message_map.get(&xid.request_id);

        if msg_holder.is_none() {
            return None;
        }
        let msg_holder = msg_holder.unwrap();
        //
        Some((msg_holder.data.clone(), msg_holder.channel_id))
    }

    fn stop(&self) {}

    fn finalize(&self) {}
}
